/**
 * 数据显示辅助工具
 * 用于安全处理和显示各种数据，避免显示null、undefined等异常值
 */

class DataDisplayHelper {
  /**
   * 安全获取用户名称
   * @param {Object} order - 订单对象
   * @returns {string} 用户名称
   */
  static safeGetUserName(order) {
    if (!order) return '未知用户';
    
    // 多层级安全获取用户昵称
    const sources = [
      () => order.User?.nickname,
      () => order.user?.nickname,
      () => order.User?.phone?.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2'),
      () => order.user?.phone?.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2'),
      () => order.userNickname,
      () => order.user_nickname,
      () => '未知用户'
    ];
    
    for (const source of sources) {
      try {
        const result = source();
        if (result && result !== 'undefined' && result !== 'null' && result.trim() !== '') {
          return result;
        }
      } catch (error) {
        continue;
      }
    }
    
    return '未知用户';
  }

  /**
   * 安全获取用户手机号
   * @param {Object} order - 订单对象
   * @returns {string} 脱敏后的手机号
   */
  static safeGetUserPhone(order) {
    if (!order) return '未绑定';
    
    const sources = [
      () => order.User?.phone,
      () => order.user?.phone,
      () => order.userPhone,
      () => order.user_phone
    ];
    
    for (const source of sources) {
      try {
        const phone = source();
        if (phone && phone !== 'undefined' && phone !== 'null' && phone.length >= 11) {
          return phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2');
        }
      } catch (error) {
        continue;
      }
    }
    
    return '未绑定';
  }

  /**
   * 安全获取商品名称
   * @param {Object} item - 订单项对象
   * @returns {string} 商品名称
   */
  static safeGetProductName(item) {
    if (!item) return '未知商品';
    
    const sources = [
      () => item.Product?.name,
      () => item.product?.name,
      () => item.productName,
      () => item.product_name,
      () => item.name
    ];
    
    for (const source of sources) {
      try {
        const result = source();
        if (result && result !== 'undefined' && result !== 'null' && result.trim() !== '') {
          return result;
        }
      } catch (error) {
        continue;
      }
    }
    
    return '未知商品';
  }

  /**
   * 安全获取商品规格
   * @param {Object} item - 订单项对象
   * @returns {string} 商品规格
   */
  static safeGetProductSpec(item) {
    if (!item) return '';
    
    const sources = [
      () => item.Product?.specification,
      () => item.product?.specification,
      () => item.specification,
      () => item.spec,
      () => item.Product?.spec,
      () => item.product?.spec
    ];
    
    for (const source of sources) {
      try {
        const result = source();
        if (result && result !== 'undefined' && result !== 'null' && result.trim() !== '') {
          return result;
        }
      } catch (error) {
        continue;
      }
    }
    
    return '';
  }

  /**
   * 安全获取订单项列表
   * @param {Object} order - 订单对象
   * @returns {Array} 订单项数组
   */
  static safeGetOrderItems(order) {
    if (!order) return [];
    
    const sources = [
      () => order.OrderItems,
      () => order.orderItems,
      () => order.items,
      () => order.order_items
    ];
    
    for (const source of sources) {
      try {
        const result = source();
        if (Array.isArray(result)) {
          return result;
        }
      } catch (error) {
        continue;
      }
    }
    
    // 尝试解析JSON字符串
    const jsonSources = [
      () => order.items,
      () => order.itemsJson,
      () => order.items_json
    ];
    
    for (const source of jsonSources) {
      try {
        const jsonStr = source();
        if (typeof jsonStr === 'string' && jsonStr.trim() !== '') {
          const parsed = JSON.parse(jsonStr);
          if (Array.isArray(parsed)) {
            return parsed;
          }
        }
      } catch (error) {
        continue;
      }
    }
    
    return [];
  }

  /**
   * 安全获取数值
   * @param {*} value - 原始值
   * @param {number} defaultValue - 默认值
   * @returns {number} 安全的数值
   */
  static safeGetNumber(value, defaultValue = 0) {
    if (value === null || value === undefined || value === '' || value === 'null' || value === 'undefined') {
      return defaultValue;
    }
    
    const num = parseFloat(value);
    return isNaN(num) ? defaultValue : num;
  }

  /**
   * 安全获取字符串
   * @param {*} value - 原始值
   * @param {string} defaultValue - 默认值
   * @returns {string} 安全的字符串
   */
  static safeGetString(value, defaultValue = '') {
    if (value === null || value === undefined || value === 'null' || value === 'undefined') {
      return defaultValue;
    }
    
    return String(value).trim();
  }

  /**
   * 安全格式化时间
   * @param {*} time - 时间值
   * @returns {string} 格式化后的时间字符串
   */
  static safeFormatTime(time) {
    if (!time || time === 'null' || time === 'undefined') {
      return '未知时间';
    }
    
    try {
      const date = new Date(time);
      if (isNaN(date.getTime())) {
        return '时间格式错误';
      }
      return date.toLocaleString('zh-CN');
    } catch (error) {
      return '时间格式错误';
    }
  }

  /**
   * 安全获取订单状态文本
   * @param {string} status - 状态值
   * @returns {string} 状态文本
   */
  static safeGetStatusText(status) {
    if (!status || status === 'null' || status === 'undefined') {
      return '未知状态';
    }
    
    const statusMap = {
      'pending': '待处理',
      'processing': '处理中',
      'completed': '已完成',
      'cancelled': '已取消',
      'paid': '已支付',
      'shipped': '已发货',
      'delivered': '已送达',
      'refunded': '已退款'
    };
    
    return statusMap[status] || status;
  }

  /**
   * 安全获取订单类型文本
   * @param {string} type - 类型值
   * @returns {string} 类型文本
   */
  static safeGetOrderType(type) {
    if (!type || type === 'null' || type === 'undefined') {
      return '普通订单';
    }
    
    const typeMap = {
      'offline': '到店兑换',
      'online': '在线处理',
      'delivery': '配送订单',
      'pickup': '自提订单'
    };
    
    return typeMap[type] || '普通订单';
  }

  /**
   * 计算订单总数量
   * @param {Object} order - 订单对象
   * @returns {number} 总数量
   */
  static calculateTotalQuantity(order) {
    const items = this.safeGetOrderItems(order);
    return items.reduce((total, item) => {
      const quantity = this.safeGetNumber(item.quantity, 0);
      return total + quantity;
    }, 0);
  }

  /**
   * 计算订单总积分
   * @param {Object} order - 订单对象
   * @returns {number} 总积分
   */
  static calculateTotalPoints(order) {
    if (!order) return 0;
    
    // 优先使用订单级别的总积分
    const orderLevelPoints = [
      () => order.totalPoints,
      () => order.total_points,
      () => order.pointsUsed,
      () => order.points_used
    ];
    
    for (const source of orderLevelPoints) {
      try {
        const points = source();
        if (points !== null && points !== undefined && points !== 'null' && points !== 'undefined') {
          return this.safeGetNumber(points, 0);
        }
      } catch (error) {
        continue;
      }
    }
    
    // 如果没有订单级别的积分，计算订单项积分总和
    const items = this.safeGetOrderItems(order);
    return items.reduce((total, item) => {
      const itemPoints = this.safeGetNumber(item.pointsUsed || item.points_used || item.unitPoints || item.unit_points, 0);
      const quantity = this.safeGetNumber(item.quantity, 1);
      return total + (itemPoints * quantity);
    }, 0);
  }

  /**
   * 验证数据完整性
   * @param {Object} data - 数据对象
   * @param {Array} requiredFields - 必需字段列表
   * @returns {Object} 验证结果
   */
  static validateDataIntegrity(data, requiredFields = []) {
    const result = {
      isValid: true,
      missingFields: [],
      invalidFields: []
    };
    
    if (!data || typeof data !== 'object') {
      result.isValid = false;
      result.missingFields = requiredFields;
      return result;
    }
    
    for (const field of requiredFields) {
      const value = data[field];
      if (value === null || value === undefined || value === 'null' || value === 'undefined' || value === '') {
        result.isValid = false;
        result.missingFields.push(field);
      }
    }
    
    return result;
  }

  /**
   * 清理数据对象，移除null和undefined值
   * @param {Object} data - 原始数据
   * @returns {Object} 清理后的数据
   */
  static cleanData(data) {
    if (!data || typeof data !== 'object') {
      return data;
    }
    
    const cleaned = {};
    
    for (const [key, value] of Object.entries(data)) {
      if (value !== null && value !== undefined && value !== 'null' && value !== 'undefined') {
        if (typeof value === 'object' && !Array.isArray(value)) {
          cleaned[key] = this.cleanData(value);
        } else {
          cleaned[key] = value;
        }
      }
    }
    
    return cleaned;
  }

  /**
   * 生成友好的错误提示
   * @param {Error} error - 错误对象
   * @param {string} context - 错误上下文
   * @returns {string} 友好的错误信息
   */
  static generateFriendlyErrorMessage(error, context = '') {
    if (!error) return '未知错误';
    
    const errorMessage = error.message || error.toString();
    
    // 网络错误
    if (errorMessage.includes('Network') || errorMessage.includes('fetch')) {
      return '网络连接异常，请检查网络后重试';
    }
    
    // 权限错误
    if (errorMessage.includes('403') || errorMessage.includes('权限')) {
      return '权限不足，请联系管理员';
    }
    
    // 认证错误
    if (errorMessage.includes('401') || errorMessage.includes('认证')) {
      return '登录已过期，请重新登录';
    }
    
    // 数据错误
    if (errorMessage.includes('数据') || errorMessage.includes('格式')) {
      return '数据格式异常，请稍后重试';
    }
    
    // 服务器错误
    if (errorMessage.includes('500') || errorMessage.includes('服务器')) {
      return '服务器繁忙，请稍后重试';
    }
    
    // 默认错误信息
    return context ? `${context}失败，请稍后重试` : '操作失败，请稍后重试';
  }
}

export default DataDisplayHelper;